home *** CD-ROM | disk | FTP | other *** search
/ Champak 40 / Vol 40.iso / games / ufo_comm.swf / scripts / __Packages / MochiAd.as
Encoding:
Text File  |  2007-04-25  |  21.0 KB  |  554 lines
  1. var ┬º\x01┬º = 296;
  2. while(true)
  3. {
  4.    if(eval("\x01") == 296)
  5.    {
  6.       set("\x01",eval("\x01") - 66);
  7.       ┬º┬ºpush(true);
  8.    }
  9.    else
  10.    {
  11.       if(eval("\x01") == 234)
  12.       {
  13.          set("\x01",eval("\x01") - 58);
  14.          break;
  15.       }
  16.       if(eval("\x01") == 872)
  17.       {
  18.          set("\x01",eval("\x01") - 638);
  19.          if(┬º┬ºpop())
  20.          {
  21.             set("\x01",eval("\x01") - 58);
  22.          }
  23.       }
  24.       else if(eval("\x01") == 107)
  25.       {
  26.          set("\x01",eval("\x01") + 635);
  27.          if(┬º┬ºpop())
  28.          {
  29.             set("\x01",eval("\x01") - 185);
  30.          }
  31.       }
  32.       else
  33.       {
  34.          if(eval("\x01") == 557)
  35.          {
  36.             set("\x01",eval("\x01") + 227);
  37.             if(!_global.MochiAd)
  38.             {
  39.                var _loc2_ = _global.MochiAd = function()
  40.                {
  41.                }.prototype;
  42.                _global.MochiAd = function()
  43.                {
  44.                }.showPreloaderAd = function(options)
  45.                {
  46.                   var _loc29_ = {clip:_root,ad_msec:11000,ad_timeout:3000,fadeout_time:250,regpt:"o",method:"showPreloaderAd",color:16747008,background:16777161,outline:13994812};
  47.                   options = MochiAd._parseOptions(options,_loc29_);
  48.                   var _loc15_ = options.clip;
  49.                   var _loc25_ = options.ad_msec;
  50.                   delete options.ad_msec;
  51.                   var _loc28_ = options.ad_timeout;
  52.                   delete options.ad_timeout;
  53.                   var fadeout_time = options.fadeout_time;
  54.                   delete options.fadeout_time;
  55.                   if(!MochiAd.load(options))
  56.                   {
  57.                      return null;
  58.                   }
  59.                   _loc15_.stop();
  60.                   var mc = _loc15_._mochiad;
  61.                   mc.onUnload = function()
  62.                   {
  63.                      this._parent.play();
  64.                   };
  65.                   var _loc16_ = MochiAd._getRes(options);
  66.                   var _loc5_ = _loc16_[0];
  67.                   var _loc14_ = _loc16_[1];
  68.                   mc._x = _loc5_ * 0.5;
  69.                   mc._y = _loc14_ * 0.5;
  70.                   var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  71.                   chk._x = _loc5_ * -0.5;
  72.                   chk._y = _loc14_ * -0.5;
  73.                   var _loc8_ = chk.createEmptyMovieClip("_mochiad_bar",4);
  74.                   _loc8_._x = 10;
  75.                   _loc8_._y = _loc14_ - 20;
  76.                   var _loc24_ = options.color;
  77.                   delete options.color;
  78.                   var _loc21_ = options.background;
  79.                   delete options.background;
  80.                   var _loc26_ = options.outline;
  81.                   delete options.outline;
  82.                   var _loc6_ = _loc8_.createEmptyMovieClip("_outline",1);
  83.                   _loc6_.beginFill(_loc21_);
  84.                   _loc6_.moveTo(0,0);
  85.                   _loc6_.lineTo(_loc5_ - 20,0);
  86.                   _loc6_.lineTo(_loc5_ - 20,10);
  87.                   _loc6_.lineTo(0,10);
  88.                   _loc6_.lineTo(0,0);
  89.                   _loc6_.endFill();
  90.                   var _loc4_ = _loc8_.createEmptyMovieClip("_inside",2);
  91.                   _loc4_.beginFill(_loc24_);
  92.                   _loc4_.moveTo(0,0);
  93.                   _loc4_.lineTo(_loc5_ - 20,0);
  94.                   _loc4_.lineTo(_loc5_ - 20,10);
  95.                   _loc4_.lineTo(0,10);
  96.                   _loc4_.lineTo(0,0);
  97.                   _loc4_.endFill();
  98.                   _loc4_._xscale = 0;
  99.                   var _loc7_ = _loc8_.createEmptyMovieClip("_outline",3);
  100.                   _loc7_.lineStyle(0,_loc26_,100);
  101.                   _loc7_.moveTo(0,0);
  102.                   _loc7_.lineTo(_loc5_ - 20,0);
  103.                   _loc7_.lineTo(_loc5_ - 20,10);
  104.                   _loc7_.lineTo(0,10);
  105.                   _loc7_.lineTo(0,0);
  106.                   chk.ad_msec = _loc25_;
  107.                   chk.ad_timeout = _loc28_;
  108.                   chk.started = getTimer();
  109.                   chk.showing = false;
  110.                   chk.last_pcnt = 0;
  111.                   chk.fadeout_time = fadeout_time;
  112.                   chk.fadeFunction = function()
  113.                   {
  114.                      var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  115.                      if(_loc2_ > 0)
  116.                      {
  117.                         this._parent._alpha = _loc2_;
  118.                      }
  119.                      else
  120.                      {
  121.                         var _loc3_ = this._parent._parent;
  122.                         MochiAd.unload(_loc3_);
  123.                         delete this.onEnterFrame;
  124.                      }
  125.                   };
  126.                   mc.lc.adjustProgress = function(msec)
  127.                   {
  128.                      var _loc2_ = this.mc._mochiad_wait;
  129.                      _loc2_.server_control = true;
  130.                      _loc2_.started = getTimer();
  131.                      _loc2_.ad_msec = msec;
  132.                   };
  133.                   chk.onEnterFrame = function()
  134.                   {
  135.                      var _loc6_ = this._parent._parent;
  136.                      var _loc12_ = this._parent._mochiad_ctr;
  137.                      var _loc5_ = getTimer() - this.started;
  138.                      var _loc3_ = false;
  139.                      var _loc4_ = _loc6_.getBytesTotal();
  140.                      var _loc8_ = _loc6_.getBytesLoaded();
  141.                      var _loc10_ = 100 * _loc8_ / _loc4_;
  142.                      var _loc11_ = 100 * _loc5_ / chk.ad_msec;
  143.                      var _loc9_ = this._mochiad_bar._inside;
  144.                      var _loc2_ = Math.min(100,Math.min(_loc10_ || 0,_loc11_));
  145.                      _loc2_ = Math.max(this.last_pcnt,_loc2_);
  146.                      this.last_pcnt = _loc2_;
  147.                      _loc9_._xscale = _loc2_;
  148.                      if(!chk.showing)
  149.                      {
  150.                         var _loc7_ = _loc12_.getBytesTotal();
  151.                         if(_loc7_ > 0 || typeof _loc7_ == "undefined")
  152.                         {
  153.                            chk.showing = true;
  154.                            chk.started = getTimer();
  155.                         }
  156.                         else if(_loc5_ > chk.ad_timeout)
  157.                         {
  158.                            _loc3_ = true;
  159.                         }
  160.                      }
  161.                      if(_loc5_ > chk.ad_msec)
  162.                      {
  163.                         _loc3_ = true;
  164.                      }
  165.                      if(_loc4_ > 0 && _loc8_ >= _loc4_ && _loc3_)
  166.                      {
  167.                         if(this.server_control)
  168.                         {
  169.                            delete this.onEnterFrame;
  170.                         }
  171.                         else
  172.                         {
  173.                            this.fadeout_start = getTimer();
  174.                            this.onEnterFrame = chk.fadeFunction;
  175.                         }
  176.                      }
  177.                   };
  178.                };
  179.                _global.MochiAd = function()
  180.                {
  181.                }.showTimedAd = function(options)
  182.                {
  183.                   var _loc15_ = {clip:_root,ad_msec:11000,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showTimedAd"};
  184.                   options = MochiAd._parseOptions(options,_loc15_);
  185.                   var _loc6_ = options.clip;
  186.                   var _loc12_ = options.ad_msec;
  187.                   delete options.ad_msec;
  188.                   var _loc14_ = options.ad_timeout;
  189.                   delete options.ad_timeout;
  190.                   var fadeout_time = options.fadeout_time;
  191.                   delete options.fadeout_time;
  192.                   if(!MochiAd.load(options))
  193.                   {
  194.                      return null;
  195.                   }
  196.                   _loc6_.stop();
  197.                   var mc = _loc6_._mochiad;
  198.                   mc.onUnload = function()
  199.                   {
  200.                      this._parent.play();
  201.                   };
  202.                   var _loc7_ = MochiAd._getRes(options);
  203.                   var _loc16_ = _loc7_[0];
  204.                   var _loc13_ = _loc7_[1];
  205.                   mc._x = _loc16_ * 0.5;
  206.                   mc._y = _loc13_ * 0.5;
  207.                   var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  208.                   chk.ad_msec = _loc12_;
  209.                   chk.ad_timeout = _loc14_;
  210.                   chk.started = getTimer();
  211.                   chk.showing = false;
  212.                   chk.fadeout_time = fadeout_time;
  213.                   chk.fadeFunction = function()
  214.                   {
  215.                      var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  216.                      if(_loc2_ > 0)
  217.                      {
  218.                         this._parent._alpha = _loc2_;
  219.                      }
  220.                      else
  221.                      {
  222.                         var _loc3_ = this._parent._parent;
  223.                         MochiAd.unload(_loc3_);
  224.                         delete this.onEnterFrame;
  225.                      }
  226.                   };
  227.                   mc.lc.adjustProgress = function(msec)
  228.                   {
  229.                      var _loc2_ = this.mc._mochiad_wait;
  230.                      _loc2_.server_control = true;
  231.                      _loc2_.started = getTimer();
  232.                      _loc2_.ad_msec = msec - 250;
  233.                   };
  234.                   chk.onEnterFrame = function()
  235.                   {
  236.                      var _loc5_ = this._parent._mochiad_ctr;
  237.                      var _loc4_ = getTimer() - this.started;
  238.                      var _loc2_ = false;
  239.                      if(!chk.showing)
  240.                      {
  241.                         var _loc3_ = _loc5_.getBytesTotal();
  242.                         if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  243.                         {
  244.                            chk.showing = true;
  245.                            chk.started = getTimer();
  246.                         }
  247.                         else if(_loc4_ > chk.ad_timeout)
  248.                         {
  249.                            _loc2_ = true;
  250.                         }
  251.                      }
  252.                      if(_loc4_ > chk.ad_msec)
  253.                      {
  254.                         _loc2_ = true;
  255.                      }
  256.                      if(_loc2_)
  257.                      {
  258.                         if(this.server_control)
  259.                         {
  260.                            delete this.onEnterFrame;
  261.                         }
  262.                         else
  263.                         {
  264.                            this.fadeout_start = getTimer();
  265.                            this.onEnterFrame = this.fadeFunction;
  266.                         }
  267.                      }
  268.                   };
  269.                };
  270.                _global.MochiAd = function()
  271.                {
  272.                }.load = function(options)
  273.                {
  274.                   var _loc14_ = {clip:_root,server:"http://x.mochiads.com/srv/1/",method:"load",depth:10333,id:"_UNKNOWN_"};
  275.                   options = MochiAd._parseOptions(options,_loc14_);
  276.                   options.swfv = options.clip.getSWFVersion() || 6;
  277.                   options.mav = "1.3";
  278.                   var _loc7_ = options.clip;
  279.                   if(!MochiAd._isNetworkAvailable())
  280.                   {
  281.                      return false;
  282.                   }
  283.                   if(_loc7_._mochiad_loaded)
  284.                   {
  285.                      return false;
  286.                   }
  287.                   var _loc13_ = options.depth;
  288.                   delete options.depth;
  289.                   var _loc6_ = _loc7_.createEmptyMovieClip("_mochiad",_loc13_);
  290.                   var _loc12_ = MochiAd._getRes(options);
  291.                   options.res = _loc12_[0] + "x" + _loc12_[1];
  292.                   options.server += options.id;
  293.                   delete options.id;
  294.                   _loc7_._mochiad_loaded = true;
  295.                   var _loc4_ = _loc6_.createEmptyMovieClip("_mochiad_ctr",1);
  296.                   for(var _loc8_ in options)
  297.                   {
  298.                      _loc4_[_loc8_] = options[_loc8_];
  299.                   }
  300.                   if(_loc7_._url.indexOf("http") != 0)
  301.                   {
  302.                      options.no_page = true;
  303.                   }
  304.                   var _loc11_ = _loc4_.server;
  305.                   delete _loc4_.server;
  306.                   var _loc10_ = _loc11_.split("/")[2].split(":")[0];
  307.                   if(System.security)
  308.                   {
  309.                      if(System.security.allowDomain)
  310.                      {
  311.                         System.security.allowDomain("*");
  312.                         System.security.allowDomain(_loc10_);
  313.                      }
  314.                      if(System.security.allowInsecureDomain)
  315.                      {
  316.                         System.security.allowInsecureDomain("*");
  317.                         System.security.allowInsecureDomain(_loc10_);
  318.                      }
  319.                   }
  320.                   _loc6_.onEnterFrame = function()
  321.                   {
  322.                      if(this._mochiad_ctr._url != this._url)
  323.                      {
  324.                         this.onEnterFrame = function()
  325.                         {
  326.                            if(!this._mochiad_ctr)
  327.                            {
  328.                               delete this.onEnterFrame;
  329.                               MochiAd.unload(this._parent);
  330.                            }
  331.                         };
  332.                      }
  333.                   };
  334.                   var _loc5_ = new LocalConnection();
  335.                   var _loc9_ = ["",Math.floor(new Date().getTime()),random(999999)].join("_");
  336.                   _loc5_.mc = _loc6_;
  337.                   _loc5_.name = _loc9_;
  338.                   _loc5_.hostname = _loc10_;
  339.                   _loc5_.allowDomain = function(d)
  340.                   {
  341.                      return true;
  342.                   };
  343.                   _loc5_.allowInsecureDomain = _loc5_.allowDomain;
  344.                   _loc5_.connect(_loc9_);
  345.                   _loc6_.lc = _loc5_;
  346.                   _loc4_.lc = _loc9_;
  347.                   _loc4_.st = getTimer();
  348.                   _loc4_.loadMovie(_loc11_ + ".swf","POST");
  349.                   return _loc6_;
  350.                };
  351.                _global.MochiAd = function()
  352.                {
  353.                }.unload = function(clip)
  354.                {
  355.                   if(typeof clip == "undefined")
  356.                   {
  357.                      clip = _root;
  358.                   }
  359.                   if(clip.clip && clip.clip._mochiad)
  360.                   {
  361.                      clip = clip.clip;
  362.                   }
  363.                   if(!clip._mochiad)
  364.                   {
  365.                      return false;
  366.                   }
  367.                   clip._mochiad.removeMovieClip();
  368.                   delete clip._mochiad_loaded;
  369.                   delete clip._mochiad;
  370.                   return true;
  371.                };
  372.                _global.MochiAd = function()
  373.                {
  374.                }._isNetworkAvailable = function()
  375.                {
  376.                   if(System.security)
  377.                   {
  378.                      var _loc1_ = System.security;
  379.                      if(_loc1_.sandboxType == "localWithFile")
  380.                      {
  381.                         return false;
  382.                      }
  383.                   }
  384.                   return true;
  385.                };
  386.                _global.MochiAd = function()
  387.                {
  388.                }._getRes = function(options)
  389.                {
  390.                   var _loc3_ = options.clip.getBounds();
  391.                   var _loc2_ = 0;
  392.                   var _loc1_ = 0;
  393.                   if(typeof options.res != "undefined")
  394.                   {
  395.                      var _loc4_ = options.res.split("x");
  396.                      _loc2_ = parseFloat(_loc4_[0]);
  397.                      _loc1_ = parseFloat(_loc4_[1]);
  398.                   }
  399.                   else
  400.                   {
  401.                      _loc2_ = _loc3_.xMax - _loc3_.xMin;
  402.                      _loc1_ = _loc3_.yMax - _loc3_.yMin;
  403.                   }
  404.                   if(_loc2_ == 0 || _loc1_ == 0)
  405.                   {
  406.                      _loc2_ = Stage.width;
  407.                      _loc1_ = Stage.height;
  408.                   }
  409.                   return [_loc2_,_loc1_];
  410.                };
  411.                _global.MochiAd = function()
  412.                {
  413.                }._parseOptions = function(options, defaults)
  414.                {
  415.                   var _loc4_ = {};
  416.                   for(var _loc8_ in defaults)
  417.                   {
  418.                      _loc4_[_loc8_] = defaults[_loc8_];
  419.                   }
  420.                   if(options)
  421.                   {
  422.                      for(_loc8_ in options)
  423.                      {
  424.                         _loc4_[_loc8_] = options[_loc8_];
  425.                      }
  426.                   }
  427.                   if(_root.mochiad_options)
  428.                   {
  429.                      var _loc5_ = _root.mochiad_options.split("&");
  430.                      var _loc2_ = 0;
  431.                      while(_loc2_ < _loc5_.length)
  432.                      {
  433.                         var _loc3_ = _loc5_[_loc2_].split("=");
  434.                         _loc4_[unescape(_loc3_[0])] = unescape(_loc3_[1]);
  435.                         _loc2_ = _loc2_ + 1;
  436.                      }
  437.                   }
  438.                   return _loc4_;
  439.                };
  440.                ┬º┬ºpush(ASSetPropFlags(_global.MochiAd.prototype,null,1));
  441.             }
  442.             ┬º┬ºpop();
  443.             break;
  444.          }
  445.          if(eval("\x01") == 230)
  446.          {
  447.             set("\x01",eval("\x01") + 384);
  448.             if(┬º┬ºpop())
  449.             {
  450.                set("\x01",eval("\x01") - 514);
  451.             }
  452.          }
  453.          else if(eval("\x01") == 363)
  454.          {
  455.             set("\x01",eval("\x01") + 509);
  456.             ┬º┬ºpush(true);
  457.          }
  458.          else
  459.          {
  460.             if(eval("\x01") == 56)
  461.             {
  462.                set("\x01",eval("\x01") + 307);
  463.                stop();
  464.                ┬º┬ºpush(┬º┬ºpop() or ┬º┬ºpop());
  465.                break;
  466.             }
  467.             if(eval("\x01") == 176)
  468.             {
  469.                set("\x01",eval("\x01") - 69);
  470.                ┬º┬ºpush(true);
  471.             }
  472.             else
  473.             {
  474.                if(eval("\x01") == 742)
  475.                {
  476.                   set("\x01",eval("\x01") - 185);
  477.                   var _loc10_ = ┬º┬ºpop()[0];
  478.                   if(System.security)
  479.                   {
  480.                      if(System.security.allowDomain)
  481.                      {
  482.                         System.security.allowDomain("*");
  483.                         System.security.allowDomain(_loc10_);
  484.                      }
  485.                      if(System.security.allowInsecureDomain)
  486.                      {
  487.                         System.security.allowInsecureDomain("*");
  488.                         System.security.allowInsecureDomain(_loc10_);
  489.                      }
  490.                   }
  491.                   _loc6_.onEnterFrame = function()
  492.                   {
  493.                      if(this._mochiad_ctr._url != this._url)
  494.                      {
  495.                         this.onEnterFrame = function()
  496.                         {
  497.                            if(!this._mochiad_ctr)
  498.                            {
  499.                               delete this.onEnterFrame;
  500.                               MochiAd.unload(this._parent);
  501.                            }
  502.                         };
  503.                      }
  504.                   };
  505.                   var _loc5_ = new LocalConnection();
  506.                   var _loc9_ = ["",Math.floor(new Date().getTime()),random(999999)].join("_");
  507.                   _loc5_.mc = _loc6_;
  508.                   _loc5_.name = _loc9_;
  509.                   _loc5_.hostname = _loc10_;
  510.                   _loc5_.allowDomain = function(d)
  511.                   {
  512.                      return true;
  513.                   };
  514.                   _loc5_.allowInsecureDomain = _loc5_.allowDomain;
  515.                   _loc5_.connect(_loc9_);
  516.                   _loc6_.lc = _loc5_;
  517.                   _loc4_.lc = _loc9_;
  518.                   _loc4_.st = getTimer();
  519.                   _loc4_.loadMovie(_loc11_ + ".swf","POST");
  520.                   return _loc6_;
  521.                }
  522.                if(eval("\x01") == 612)
  523.                {
  524.                   set("\x01",eval("\x01") - 556);
  525.                   if(┬º┬ºpop())
  526.                   {
  527.                      set("\x01",eval("\x01") + 307);
  528.                   }
  529.                }
  530.                else
  531.                {
  532.                   if(eval("\x01") == 784)
  533.                   {
  534.                      set("\x01",eval("\x01") - 784);
  535.                      break;
  536.                   }
  537.                   if(eval("\x01") != 100)
  538.                   {
  539.                      if(eval("\x01") == 614)
  540.                      {
  541.                         set("\x01",eval("\x01") - 514);
  542.                         ┬º┬ºpush(┬º┬ºpop() << (┬º┬ºpop() >>> ┬º┬ºpop()));
  543.                      }
  544.                      break;
  545.                   }
  546.                   set("\x01",eval("\x01") + 512);
  547.                   ┬º┬ºpush(true);
  548.                }
  549.             }
  550.          }
  551.       }
  552.    }
  553. }
  554.